// 题目描述
// 给定一个表达式，求其分数计算结果。

// 表达式的限制如下：
// 所有的输入数字皆为正整数（包括0）
// 仅支持四则运算（+-*/）和括号
// 结果为整数或分数，分数必须化为最简格式（比如6，3/4，7/8，90/7）
// 除数可能为0，如果遇到这种情况，直接输出"ERROR"
// 输入和最终计算结果中的数字都不会超出整型范围
// 用例输入一定合法，不会出现括号匹配的情况

// 输入描述
// 字符串格式的表达式，仅支持+-*/，数字可能超过两位，可能带有空格，没有负数
// 长度小于200个字符

// 输出描述
// 表达式结果，以最简格式表达
// 如果结果为整数，那么直接输出整数
// 如果结果为负数，那么分子分母不可再约分，可以为假分数，不可表达为带分数
// 结果可能是负数，符号放在前面

// 用例1
// 输入
// 1 + 5 * 7 / 8
// 输出
// 43/8
// 用例2
// 输入
// 1 / (0 - 5)
// 输出
// -1/5
// 说明
// 符号需要提到最前面

// 用例3
// 输入
// 1 * (3*4/(8-(7+0)))
// 输出
// 12


function start() {
  let strArr = "1 / (0 - 5)".split(' ').join(''),
    numStack = [],
    symbolStack = [],
    curIndex = 0,
    flag = true;
  while (flag && curIndex < strArr.length) {
    let num = "";
    if (strArr[curIndex] >= '0' && strArr[curIndex] <= '9') {
      while (strArr[curIndex] >= '0' && strArr[curIndex] <= '9') {
        num += strArr[curIndex]
        curIndex++
        if (curIndex >= strArr.length) {
          break;
        }
      }
      numStack.push(new Num(+num, 1))
      continue
    } else if (strArr[curIndex] === '(') {
      symbolStack.push('(')
    } else if (strArr[curIndex] === ')') {
      while (symbolStack[symbolStack.length - 1] !== '(') {
        if (calc(numStack, symbolStack) === "ERROR") {
          flag = false;
          break
        }
      }
      symbolStack.pop()
    } else {
      let symbolLevel = { '+': 1, '-': 1, '*': 2, '/': 2 }
      while (symbolStack.length >= 1 &&
        symbolStack[symbolStack.length - 1] !== '(' &&
        symbolLevel[strArr[curIndex]] <= symbolLevel[symbolStack[symbolStack.length - 1]]) {
        if (calc(numStack, symbolStack) === "ERROR") {
          flag = false;
          break
        }
      }
      symbolStack.push(strArr[curIndex])
    }
    curIndex++
  }

  while (symbolStack.length > 0) {
    if (calc(numStack, symbolStack) === "ERROR") {
      flag = false;
      break
    }
  }

  if (numStack.length !== 1) {
    flag = false
  }

  if (!flag) {
    console.log("ERROR")
    return
  }

  let maxG = calG(numStack[0].fz, numStack[0].fm),
    fz = numStack[0].fz / maxG,
    fm = numStack[0].fm / maxG,
    sign = 1;
  if (fz < 0) {
    sign = -sign
    fz = -fz
  }
  if (fm < 0) {
    sign = -sign
    fm = -fm
  }

  if(fm === 1){
    console.log(sign > 0 ? fz : `-${fz}`)
  }else{
    console.log(sign > 0 ? `${fz}/${fm}` : `-${fz}/${fm}`)
  }
}

function calG(a, b) {
  while (b !== 0) {
    [a, b] = [b, a % b]
  }

  return Math.abs(a)
}

function calc(numStack, symbolStack) {
  if (numStack.length < 2 || symbolStack.length === 0) return
  let n2 = numStack.pop(),
    n1 = numStack.pop(),
    symbol = symbolStack.pop(),
    result = new Num()
  if (symbol === '+') {
    result.fz = n1.fz * n2.fm + n2.fz * n1.fm
    result.fm = n1.fm * n2.fm
  } else if (symbol === '-') {
    result.fz = n1.fz * n2.fm - n2.fz * n1.fm
    result.fm = n1.fm * n2.fm
  } else if (symbol === '*') {
    result.fz = n1.fz * n2.fz
    result.fm = n1.fm * n2.fm
  } else if (symbol === '/') {
    if (n2 === 0) {
      return "ERROR"
    }
    result.fz = n1.fz * n2.fm
    result.fm = n1.fm * n2.fz
  }
  numStack.push(result)
}

class Num {
  constructor(fz, fm) {
    this.fz = fz;
    this.fm = fm;
  }
}

start()